package com.ddm.service.impl.webImpl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ddm.constant.MessageConstant;
import com.ddm.dto.webDTO.MarketAnDTO;
import com.ddm.entity.webEntity.MarketA;
import com.ddm.exception.DataErrorException;
import com.ddm.mapper.BookmarkMapper;
import com.ddm.mapper.MarketAMapper;
import com.ddm.result.PageResult;
import com.ddm.service.vxService.UserService;
import com.ddm.service.webService.MarketAService;
import com.ddm.utils.BeanCopyUtil;
import com.ddm.vo.webVo.MarketAnVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
 *沉香课堂 服务实现类
 * </p>
 *
 * @author lwj
 * @since 2025-05-7
 */
@Slf4j
@Service
public class MarketAServiceImpl extends ServiceImpl<MarketAMapper, MarketA> implements MarketAService {

    @Autowired
    private MarketAMapper marketMapper;
    @Autowired
    private MarketAService mService;
    @Autowired
    private UserService userService;
    @Autowired
    private BookmarkMapper bookmarkMapper;
//    @Override
//    public Result<Market> getById(Long id) {
//        Market market = baseMapper.selectById(id);
//        return market != null ? Result.success(market) : Result.error("记录不存在");
//    }
//
//    @Override
//    public Result<Boolean> saveMarket(Market market) {
//        boolean success = save(market);
//        return success ? Result.success(true) : Result.error("保存失败");
//    }
//
//    @Override
//    public Result<Boolean> updateMarket(Market market) {
//        boolean success = updateById(market);
//        return success ? Result.success(true) : Result.error("更新失败");
//    }
//
//    @Override
//    public Result<Boolean> deleteById(Long id) {
//        boolean success = removeById(id);
//        return success ? Result.success(true) : Result.error("删除失败");
//    }


    /**
     * 分页查询市场分析报告列表,根据用户类型筛选
     * @param mDTO
     * @return
     */
    @Override
    public PageResult getMarketAnListByUserType(MarketAnDTO mDTO) {
//        // 从上下文获取当前用户ID
//        Long userId = BaseContext.getCurrentId();
//
//
//        // 查询用户类型
//        Integer userType = userService.getUserTypeById(userId);
//
        // 构建查询条件
        LambdaQueryWrapper<MarketA> queryWrapper = new LambdaQueryWrapper<>();
//
//        // 根据用户类型过滤可见文档
//        if (userType == 0) { // 普通用户只能查看普通文档(0)
//            queryWrapper.eq(Market::getAType, 0);
//        } else if (userType == 1 || userType == 2|| userType == 3) {
//            // 管理员，收费用户和VIP用户可以查看所有文档
//            // 无需添加额外条件
//        } else {
//            throw new DataErrorException(MessageConstant.ERROR_DATA);
//        }

        // 通用查询条件
        queryWrapper.orderByAsc(MarketA::getAPublishDate);
        String keyword = mDTO.getKey();
        if (keyword != null && !keyword.trim().isEmpty()) {
            queryWrapper.like(MarketA::getATitle, keyword)
                    .or()
                    .like(MarketA::getAPublishMan, keyword)
                    .or()
                    .like(MarketA::getAAbstract, keyword);
        }
        // 执行分页查询
        Page<MarketA> page = new Page<>(mDTO.getPage(), mDTO.getPageSize());
        IPage<MarketA> marketPage = mService.page(page, queryWrapper);

        // 转换结果
        List<MarketAnVO> marketAnVOs = BeanCopyUtil.BeanCopyList(
                marketPage.getRecords(),
                MarketAnVO.class
        );

        return new PageResult(marketPage.getTotal(), marketAnVOs);
    }
//    /**
//     * 分页查询市场分析列表
//     * @param pageQueryDTO
//     * @return
//     */
//    @Override
//    public PageResult getMarketAnList(PageQueryDTO pageQueryDTO) {
//        LambdaQueryWrapper<Market> queryWrapper = new LambdaQueryWrapper<>();
//        Page<Market> classPage = new Page(pageQueryDTO.getPage() , pageQueryDTO.getPageSize());
//        queryWrapper.orderByAsc(Market::getAPublishDate);
//        List<Market> records = mService.page(classPage, queryWrapper).getRecords();
//        long total = classPage.getTotal();
//        List<MarketAnVO> MarketAnVOs = BeanCopyUtil.BeanCopyList(records, MarketAnVO.class);
//        return new PageResult(total,MarketAnVOs);
//    }

//    /**
//     * 通过DTO中的aTitle和aPublishDate获取文档ID（内部辅助方法）
//     * 要求aTitle和aPublishDate必须同时存在且唯一对应一条记录
//     * @param marketAnDTO 市场分析文档DTO
//     * @return 文档ID
//     */
//    private Long getIdByUniqueFields(MarketAnDTO marketAnDTO) {
//        // 校验aTitle和aPublishDate是否同时存在
//        if (marketAnDTO.getAPublishMan() == null || marketAnDTO.getAPublishDate() == null) {
//            throw new IllegalArgumentException("aPublishMan和aPublishDate必须同时提供");
//        }
//
//        // 构建查询条件（通过aTitle和aPublishDate定位唯一记录）
//        LambdaQueryWrapper<MarketA> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.eq(MarketA::getAPublishMan, marketAnDTO.getAPublishMan())
//                .eq(MarketA::getAPublishDate, marketAnDTO.getAPublishDate());
//
//        // 查询记录并获取ID
//        MarketA marketA = mService.getOne(queryWrapper);
//        if (marketA == null) {
//            log.error("获取教室ID失败：未找到匹配记录，Publisher={}, PublishDate={}",
//                    marketAnDTO.getAPublishMan(), marketAnDTO.getAPublishDate());
//
//            throw new DataErrorException(MessageConstant.ERROR_DATA);
//        }
//
//        return marketA.getId();
//    }
    /**
     * 添加市场分析文档
     * @param marketAnDTO 市场分析文档DTO
     * @return 添加结果
     */
    @Override
    public boolean addMarketAn(MarketAnDTO marketAnDTO) {
        if (marketAnDTO.getATitle() == null || marketAnDTO.getATitle().trim().isEmpty()) {

            throw new IllegalArgumentException("文档标题(aTitle)不能为空");
        }
        // 转换DTO为实体类
        MarketA marketA = BeanCopyUtil.BeanCopy(marketAnDTO, MarketA.class);

        // 设置默认发布时间（如果DTO中未包含）
        if (marketA.getAPublishDate() == null) {
            marketA.setAPublishDate(LocalDateTime.now());
        }

        // 执行添加操作
         mService.save(marketA);
        return true;
    }

    /**
     * 根据DTO中的aTitle和aPublishDate删除市场分析文档
     * @param id
     * @return 删除结果
     */
    @Override
    public boolean deleteMarketAn(long id) {

        MarketA a=mService.getById(id);
        if (a == null) {
            throw new DataErrorException(MessageConstant.ERROR_DATA);
        }
        // 执行删除操作
         mService.removeById(id);
        return true;
    }

    /**
     * 根据DTO中的aTitle和aPublishDate更新市场分析文档
     * @param marketAnDTO 市场分析文档DTO
     * @return 更新结果
     */
    @Override
    public boolean updateMarketAn(MarketAnDTO marketAnDTO) {
        // 获取文档ID（要求aTitle和aPublishDate必须同时存在）
        Long id = marketAnDTO.getId();
        MarketA a=mService.getById(id);
        if (a == null) {
            throw new DataErrorException(MessageConstant.ERROR_DATA);
        }
        // 转换DTO为实体类并设置ID
        MarketA marketA = BeanCopyUtil.BeanCopy(marketAnDTO, MarketA.class);
        marketA.setId(id); // 覆盖ID，确保更新目标正确

        // 执行更新操作
         mService.updateById(marketA);
        return true;
    }

    /**
     * 根据用户收藏数据返回市场分析分页数据
     *
     * @return
     */
    public IPage<MarketA> getCollectedMarketAnByUserId(Page<MarketA> page, Integer userId, String key) {
        // 打印方法入参，确认分页参数、用户ID和关键词
        log.info("开始查询用户收藏市场分析报告userId: {}, 页码: {}, 每页条数: {}, 关键词: {}",
                userId, page.getCurrent(), page.getSize(), key);

        // 1. 查询用户收藏的所有course_id
        log.info("Step 1: 查询用户[{}]收藏的marketAn_id列表", userId);
        List<Integer> marketAnIds = bookmarkMapper.selectMarketAnIdsByUserId(userId);
        // 过滤掉null值
        marketAnIds = marketAnIds.stream()
                .filter(Objects::nonNull) // 保留非null的id
                .collect(Collectors.toList());
        log.info("Step 1结果: 收藏的marketAn_id数量为: {}", marketAnIds != null ? marketAnIds.size() : 0);
        if (!CollectionUtils.isEmpty(marketAnIds)) {
            log.info("Step 1详情: 收藏的marketAn_id列表: {}", marketAnIds); // 仅调试用
        }

        // 2. 处理无收藏课程情况，返回包含分页参数的空结果
        if (CollectionUtils.isEmpty(marketAnIds)) {
            log.info("Step 2: 用户[{}]无收藏市场分析报告，返回空分页", userId);
            Page<MarketA> emptyPage = new Page<>(page.getCurrent(), page.getSize());
            emptyPage.setTotal(0);
            return emptyPage;
        }

        // 3. 构造查询条件：先锁定收藏课程范围，再做关键词搜索
        log.info("Step 3: 构造查询条件 | 关键词: {}", key);
        LambdaQueryWrapper<MarketA> lambdaWrapper = new LambdaQueryWrapper<>();
        lambdaWrapper.in(MarketA::getId, marketAnIds)
                .last(""); // 关键：清除 MyBatis-Plus 自动添加的 WHERE deleted=0
        log.info("Step 3条件: 已添加收藏市场分析报告ID范围筛选（共{}个ID）", marketAnIds.size());

        if (StrUtil.isNotBlank(key)) {
            lambdaWrapper.nested(q -> q
                    .like(MarketA::getATitle, key)
                    .or()
                    .like(MarketA::getAPublishMan, key)
                    .or()
                    .eq(MarketA::getAReportType, key)
            );
            log.info("Step 3条件: 已添加关键词[{}]的模糊查询（匹配报告名、发布人、类型）", key);
        } else {
            log.info("Step 3条件: 无关键词，仅查询收藏市场报告");
        }

        // 4. 分页查询
        log.info("Step 4: 执行分页查询 | SQL条件: {}", lambdaWrapper.getSqlSegment()); // 打印SQL条件片段
        IPage<MarketA> resultPage = baseMapper.selectPage(page, lambdaWrapper);

        // 打印查询结果
        log.info("Step 4结果: 总记录数: {}, 当前页记录数: {}, 页码: {}",
                resultPage.getTotal(),
                resultPage.getRecords().size(),
                resultPage.getCurrent());

        return resultPage;
    }
}
